home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 November / PCWNOV08.iso / Software / Freeware / Adobe Media Player 1.1 / adobe_media_player.air / AMP.swf / scripts / mx / utils / ObjectUtil.as < prev    next >
Encoding:
Text File  |  2008-07-17  |  25.9 KB  |  842 lines
  1. package mx.utils
  2. {
  3.    import flash.utils.ByteArray;
  4.    import flash.utils.Dictionary;
  5.    import flash.utils.getQualifiedClassName;
  6.    import flash.xml.XMLNode;
  7.    import mx.collections.IList;
  8.    import mx.core.mx_internal;
  9.    
  10.    use namespace mx_internal;
  11.    
  12.    public class ObjectUtil
  13.    {
  14.       mx_internal static const VERSION:String = "3.0.0.0";
  15.       
  16.       private static var defaultToStringExcludes:Array = ["password","credentials"];
  17.       
  18.       private static var refCount:int = 0;
  19.       
  20.       private static var CLASS_INFO_CACHE:Object = {};
  21.       
  22.       public function ObjectUtil()
  23.       {
  24.          super();
  25.       }
  26.       
  27.       public static function isSimple(param1:Object) : Boolean
  28.       {
  29.          var _loc2_:* = typeof param1;
  30.          switch(_loc2_)
  31.          {
  32.             case "number":
  33.             case "string":
  34.             case "boolean":
  35.                return true;
  36.             case "object":
  37.                return param1 is Date || param1 is Array;
  38.             default:
  39.                return false;
  40.          }
  41.       }
  42.       
  43.       private static function internalToString(param1:Object, param2:int = 0, param3:Dictionary = null, param4:Array = null, param5:Array = null) : String
  44.       {
  45.          var str:String = null;
  46.          var classInfo:Object = null;
  47.          var properties:Array = null;
  48.          var id:Object = null;
  49.          var isArray:Boolean = false;
  50.          var prop:* = undefined;
  51.          var j:int = 0;
  52.          var value:Object = param1;
  53.          var indent:int = param2;
  54.          var refs:Dictionary = param3;
  55.          var namespaceURIs:Array = param4;
  56.          var exclude:Array = param5;
  57.          var type:String = value == null ? "null" : typeof value;
  58.          switch(type)
  59.          {
  60.             case "boolean":
  61.             case "number":
  62.                return value.toString();
  63.             case "string":
  64.                return "\"" + value.toString() + "\"";
  65.             case "object":
  66.                if(value is Date)
  67.                {
  68.                   return value.toString();
  69.                }
  70.                if(value is XMLNode)
  71.                {
  72.                   return value.toString();
  73.                }
  74.                if(value is Class)
  75.                {
  76.                   return "(" + getQualifiedClassName(value) + ")";
  77.                }
  78.                classInfo = getClassInfo(value,exclude,{
  79.                   "includeReadOnly":true,
  80.                   "uris":namespaceURIs
  81.                });
  82.                properties = classInfo.properties;
  83.                str = "(" + classInfo.name + ")";
  84.                if(refs == null)
  85.                {
  86.                   refs = new Dictionary(true);
  87.                }
  88.                id = refs[value];
  89.                if(id != null)
  90.                {
  91.                   str += "#" + int(id);
  92.                   return str;
  93.                }
  94.                if(value != null)
  95.                {
  96.                   str += "#" + refCount.toString();
  97.                   refs[value] = refCount;
  98.                   ++refCount;
  99.                }
  100.                isArray = value is Array;
  101.                indent += 2;
  102.                j = 0;
  103.                while(j < properties.length)
  104.                {
  105.                   str = newline(str,indent);
  106.                   prop = properties[j];
  107.                   if(isArray)
  108.                   {
  109.                      str += "[";
  110.                   }
  111.                   str += prop.toString();
  112.                   if(isArray)
  113.                   {
  114.                      str += "] ";
  115.                   }
  116.                   else
  117.                   {
  118.                      str += " = ";
  119.                   }
  120.                   try
  121.                   {
  122.                      str += internalToString(value[prop],indent,refs,namespaceURIs,exclude);
  123.                   }
  124.                   catch(e:Error)
  125.                   {
  126.                      str += "?";
  127.                   }
  128.                   j++;
  129.                }
  130.                indent -= 2;
  131.                return str;
  132.                break;
  133.             case "xml":
  134.                return value.toString();
  135.             default:
  136.                return "(" + type + ")";
  137.          }
  138.       }
  139.       
  140.       public static function getClassInfo(param1:Object, param2:Array = null, param3:Object = null) : Object
  141.       {
  142.          var propertyNames:Array;
  143.          var isArray:Boolean;
  144.          var excludeObject:Object;
  145.          var dynamic:Boolean;
  146.          var n:int = 0;
  147.          var i:int = 0;
  148.          var result:Object = null;
  149.          var cacheKey:String = null;
  150.          var className:String = null;
  151.          var classAlias:String = null;
  152.          var properties:XMLList = null;
  153.          var prop:XML = null;
  154.          var metadataInfo:Object = null;
  155.          var classInfo:XML = null;
  156.          var numericIndex:Boolean = false;
  157.          var p:String = null;
  158.          var pi:Number = NaN;
  159.          var uris:Array = null;
  160.          var uri:String = null;
  161.          var qName:QName = null;
  162.          var j:int = 0;
  163.          var obj:Object = param1;
  164.          var excludes:Array = param2;
  165.          var options:Object = param3;
  166.          if(obj is ObjectProxy)
  167.          {
  168.             obj = ObjectProxy(obj).object_proxy::object;
  169.          }
  170.          if(options == null)
  171.          {
  172.             options = {
  173.                "includeReadOnly":true,
  174.                "uris":null,
  175.                "includeTransient":true
  176.             };
  177.          }
  178.          propertyNames = [];
  179.          dynamic = false;
  180.          if(typeof obj == "xml")
  181.          {
  182.             className = "XML";
  183.             properties = obj.text();
  184.             if(properties.length())
  185.             {
  186.                propertyNames.push("*");
  187.             }
  188.             properties = obj.attributes();
  189.          }
  190.          else
  191.          {
  192.             classInfo = DescribeTypeCache.describeType(obj).typeDescription;
  193.             className = classInfo.@name.toString();
  194.             classAlias = classInfo.@alias.toString();
  195.             dynamic = classInfo.@isDynamic.toString() == "true";
  196.             if(options.includeReadOnly)
  197.             {
  198.                properties = classInfo..accessor.(@access != "writeonly") + classInfo..variable;
  199.             }
  200.             else
  201.             {
  202.                properties = classInfo..accessor.(@access == "readwrite") + classInfo..variable;
  203.             }
  204.             numericIndex = false;
  205.          }
  206.          if(!dynamic)
  207.          {
  208.             cacheKey = getCacheKey(obj,excludes,options);
  209.             result = CLASS_INFO_CACHE[cacheKey];
  210.             if(result != null)
  211.             {
  212.                return result;
  213.             }
  214.          }
  215.          result = {};
  216.          result["name"] = className;
  217.          result["alias"] = classAlias;
  218.          result["properties"] = propertyNames;
  219.          result["dynamic"] = dynamic;
  220.          result["metadata"] = metadataInfo = recordMetadata(properties);
  221.          excludeObject = {};
  222.          if(excludes)
  223.          {
  224.             n = int(excludes.length);
  225.             i = 0;
  226.             while(i < n)
  227.             {
  228.                excludeObject[excludes[i]] = 1;
  229.                i++;
  230.             }
  231.          }
  232.          isArray = className == "Array";
  233.          if(dynamic)
  234.          {
  235.             for(p in obj)
  236.             {
  237.                if(excludeObject[p] != 1)
  238.                {
  239.                   if(isArray)
  240.                   {
  241.                      pi = parseInt(p);
  242.                      if(isNaN(pi))
  243.                      {
  244.                         propertyNames.push(new QName("",p));
  245.                      }
  246.                      else
  247.                      {
  248.                         propertyNames.push(pi);
  249.                      }
  250.                   }
  251.                   else
  252.                   {
  253.                      propertyNames.push(new QName("",p));
  254.                   }
  255.                }
  256.             }
  257.             numericIndex = isArray && !isNaN(Number(p));
  258.          }
  259.          if(!(className == "Object" || isArray))
  260.          {
  261.             if(className == "XML")
  262.             {
  263.                n = int(properties.length());
  264.                i = 0;
  265.                while(i < n)
  266.                {
  267.                   p = properties[i].name();
  268.                   if(excludeObject[p] != 1)
  269.                   {
  270.                      propertyNames.push(new QName("","@" + p));
  271.                   }
  272.                   i++;
  273.                }
  274.             }
  275.             else
  276.             {
  277.                n = int(properties.length());
  278.                uris = options.uris;
  279.                i = 0;
  280.                for(; i < n; i++)
  281.                {
  282.                   prop = properties[i];
  283.                   p = prop.@name.toString();
  284.                   uri = prop.@uri.toString();
  285.                   if(excludeObject[p] != 1)
  286.                   {
  287.                      if(!(!options.includeTransient && internalHasMetadata(metadataInfo,p,"Transient")))
  288.                      {
  289.                         if(uris != null)
  290.                         {
  291.                            if(uris.length == 1 && uris[0] == "*")
  292.                            {
  293.                               qName = new QName(uri,p);
  294.                               try
  295.                               {
  296.                                  obj[qName];
  297.                                  propertyNames.push();
  298.                               }
  299.                               catch(e:Error)
  300.                               {
  301.                               }
  302.                            }
  303.                            else
  304.                            {
  305.                               j = 0;
  306.                               while(j < uris.length)
  307.                               {
  308.                                  uri = uris[j];
  309.                                  if(prop.@uri.toString() == uri)
  310.                                  {
  311.                                     qName = new QName(uri,p);
  312.                                     try
  313.                                     {
  314.                                        obj[qName];
  315.                                        propertyNames.push(qName);
  316.                                     }
  317.                                     catch(e:Error)
  318.                                     {
  319.                                     }
  320.                                  }
  321.                                  j++;
  322.                               }
  323.                            }
  324.                         }
  325.                         else if(uri.length == 0)
  326.                         {
  327.                            qName = new QName(uri,p);
  328.                            try
  329.                            {
  330.                               obj[qName];
  331.                               propertyNames.push(qName);
  332.                            }
  333.                            catch(e:Error)
  334.                            {
  335.                            }
  336.                            continue;
  337.                         }
  338.                      }
  339.                   }
  340.                }
  341.             }
  342.          }
  343.          propertyNames.sort(Array.CASEINSENSITIVE | (numericIndex ? Array.NUMERIC : 0));
  344.          i = 0;
  345.          while(i < propertyNames.length - 1)
  346.          {
  347.             if(propertyNames[i].toString() == propertyNames[i + 1].toString())
  348.             {
  349.                propertyNames.splice(i,1);
  350.                i--;
  351.             }
  352.             i++;
  353.          }
  354.          if(!dynamic)
  355.          {
  356.             cacheKey = getCacheKey(obj,excludes,options);
  357.             CLASS_INFO_CACHE[cacheKey] = result;
  358.          }
  359.          return result;
  360.       }
  361.       
  362.       private static function arrayCompare(param1:Array, param2:Array, param3:int, param4:int, param5:Dictionary) : int
  363.       {
  364.          var _loc7_:Object = null;
  365.          var _loc6_:int = 0;
  366.          if(param1.length != param2.length)
  367.          {
  368.             if(param1.length < param2.length)
  369.             {
  370.                _loc6_ = -1;
  371.             }
  372.             else
  373.             {
  374.                _loc6_ = 1;
  375.             }
  376.          }
  377.          else
  378.          {
  379.             for(_loc7_ in param1)
  380.             {
  381.                if(!param2.hasOwnProperty(_loc7_))
  382.                {
  383.                   return -1;
  384.                }
  385.                _loc6_ = internalCompare(param1[_loc7_],param2[_loc7_],param3,param4,param5);
  386.                if(_loc6_ != 0)
  387.                {
  388.                   return _loc6_;
  389.                }
  390.             }
  391.             for(_loc7_ in param2)
  392.             {
  393.                if(!param1.hasOwnProperty(_loc7_))
  394.                {
  395.                   return 1;
  396.                }
  397.             }
  398.          }
  399.          return _loc6_;
  400.       }
  401.       
  402.       public static function stringCompare(param1:String, param2:String, param3:Boolean = false) : int
  403.       {
  404.          if(param1 == null && param2 == null)
  405.          {
  406.             return 0;
  407.          }
  408.          if(param1 == null)
  409.          {
  410.             return 1;
  411.          }
  412.          if(param2 == null)
  413.          {
  414.             return -1;
  415.          }
  416.          if(param3)
  417.          {
  418.             param1 = param1.toLocaleLowerCase();
  419.             param2 = param2.toLocaleLowerCase();
  420.          }
  421.          var _loc4_:int = int(param1.localeCompare(param2));
  422.          if(_loc4_ < -1)
  423.          {
  424.             _loc4_ = -1;
  425.          }
  426.          else if(_loc4_ > 1)
  427.          {
  428.             _loc4_ = 1;
  429.          }
  430.          return _loc4_;
  431.       }
  432.       
  433.       public static function dateCompare(param1:Date, param2:Date) : int
  434.       {
  435.          if(param1 == null && param2 == null)
  436.          {
  437.             return 0;
  438.          }
  439.          if(param1 == null)
  440.          {
  441.             return 1;
  442.          }
  443.          if(param2 == null)
  444.          {
  445.             return -1;
  446.          }
  447.          var _loc3_:Number = Number(param1.getTime());
  448.          var _loc4_:Number = Number(param2.getTime());
  449.          if(_loc3_ < _loc4_)
  450.          {
  451.             return -1;
  452.          }
  453.          if(_loc3_ > _loc4_)
  454.          {
  455.             return 1;
  456.          }
  457.          return 0;
  458.       }
  459.       
  460.       public static function numericCompare(param1:Number, param2:Number) : int
  461.       {
  462.          if(isNaN(param1) && isNaN(param2))
  463.          {
  464.             return 0;
  465.          }
  466.          if(isNaN(param1))
  467.          {
  468.             return 1;
  469.          }
  470.          if(isNaN(param2))
  471.          {
  472.             return -1;
  473.          }
  474.          if(param1 < param2)
  475.          {
  476.             return -1;
  477.          }
  478.          if(param1 > param2)
  479.          {
  480.             return 1;
  481.          }
  482.          return 0;
  483.       }
  484.       
  485.       private static function newline(param1:String, param2:int = 0) : String
  486.       {
  487.          var _loc3_:* = param1;
  488.          _loc3_ += "\n";
  489.          var _loc4_:int = 0;
  490.          while(_loc4_ < param2)
  491.          {
  492.             _loc3_ += " ";
  493.             _loc4_++;
  494.          }
  495.          return _loc3_;
  496.       }
  497.       
  498.       private static function recordMetadata(param1:XMLList) : Object
  499.       {
  500.          var prop:XML = null;
  501.          var propName:String = null;
  502.          var metadataList:XMLList = null;
  503.          var metadata:Object = null;
  504.          var md:XML = null;
  505.          var mdName:String = null;
  506.          var argsList:XMLList = null;
  507.          var value:Object = null;
  508.          var arg:XML = null;
  509.          var existing:Object = null;
  510.          var argKey:String = null;
  511.          var argValue:String = null;
  512.          var existingArray:Array = null;
  513.          var properties:XMLList = param1;
  514.          var result:Object = null;
  515.          try
  516.          {
  517.             for each(prop in properties)
  518.             {
  519.                propName = prop.attribute("name").toString();
  520.                metadataList = prop.metadata;
  521.                if(metadataList.length() > 0)
  522.                {
  523.                   if(result == null)
  524.                   {
  525.                      result = {};
  526.                   }
  527.                   metadata = {};
  528.                   result[propName] = metadata;
  529.                   for each(md in metadataList)
  530.                   {
  531.                      mdName = md.attribute("name").toString();
  532.                      argsList = md.arg;
  533.                      value = {};
  534.                      for each(arg in argsList)
  535.                      {
  536.                         argKey = arg.attribute("key").toString();
  537.                         if(argKey != null)
  538.                         {
  539.                            argValue = arg.attribute("value").toString();
  540.                            value[argKey] = argValue;
  541.                         }
  542.                      }
  543.                      existing = metadata[mdName];
  544.                      if(existing != null)
  545.                      {
  546.                         if(existing is Array)
  547.                         {
  548.                            existingArray = existing as Array;
  549.                         }
  550.                         else
  551.                         {
  552.                            existingArray = [];
  553.                         }
  554.                         existingArray.push(value);
  555.                         existing = existingArray;
  556.                      }
  557.                      else
  558.                      {
  559.                         existing = value;
  560.                      }
  561.                      metadata[mdName] = existing;
  562.                   }
  563.                }
  564.             }
  565.          }
  566.          catch(e:Error)
  567.          {
  568.          }
  569.          return result;
  570.       }
  571.       
  572.       public static function compare(param1:Object, param2:Object, param3:int = -1) : int
  573.       {
  574.          return internalCompare(param1,param2,0,param3,new Dictionary(true));
  575.       }
  576.       
  577.       private static function listCompare(param1:IList, param2:IList, param3:int, param4:int, param5:Dictionary) : int
  578.       {
  579.          var _loc7_:int = 0;
  580.          var _loc6_:int = 0;
  581.          if(param1.length != param2.length)
  582.          {
  583.             if(param1.length < param2.length)
  584.             {
  585.                _loc6_ = -1;
  586.             }
  587.             else
  588.             {
  589.                _loc6_ = 1;
  590.             }
  591.          }
  592.          else
  593.          {
  594.             _loc7_ = 0;
  595.             while(_loc7_ < param1.length)
  596.             {
  597.                _loc6_ = internalCompare(param1.getItemAt(_loc7_),param2.getItemAt(_loc7_),param3 + 1,param4,param5);
  598.                if(_loc6_ != 0)
  599.                {
  600.                   _loc7_ = param1.length;
  601.                }
  602.                _loc7_++;
  603.             }
  604.          }
  605.          return _loc6_;
  606.       }
  607.       
  608.       private static function internalCompare(param1:Object, param2:Object, param3:int, param4:int, param5:Dictionary) : int
  609.       {
  610.          var _loc9_:int = 0;
  611.          var _loc10_:Boolean = false;
  612.          var _loc11_:Boolean = false;
  613.          var _loc12_:Array = null;
  614.          var _loc13_:Array = null;
  615.          var _loc14_:QName = null;
  616.          var _loc15_:Object = null;
  617.          var _loc16_:Object = null;
  618.          var _loc17_:int = 0;
  619.          if(param1 == null && param2 == null)
  620.          {
  621.             return 0;
  622.          }
  623.          if(param1 == null)
  624.          {
  625.             return 1;
  626.          }
  627.          if(param2 == null)
  628.          {
  629.             return -1;
  630.          }
  631.          if(param1 is ObjectProxy)
  632.          {
  633.             param1 = ObjectProxy(param1).object_proxy::object;
  634.          }
  635.          if(param2 is ObjectProxy)
  636.          {
  637.             param2 = ObjectProxy(param2).object_proxy::object;
  638.          }
  639.          var _loc6_:* = typeof param1;
  640.          var _loc7_:* = typeof param2;
  641.          var _loc8_:int = 0;
  642.          if(_loc6_ == _loc7_)
  643.          {
  644.             switch(_loc6_)
  645.             {
  646.                case "boolean":
  647.                   _loc8_ = numericCompare(Number(param1),Number(param2));
  648.                   break;
  649.                case "number":
  650.                   _loc8_ = numericCompare(param1 as Number,param2 as Number);
  651.                   break;
  652.                case "string":
  653.                   _loc8_ = stringCompare(param1 as String,param2 as String);
  654.                   break;
  655.                case "object":
  656.                   _loc9_ = param4 > 0 ? param4 - 1 : param4;
  657.                   _loc10_ = Boolean(param5[param1]);
  658.                   _loc11_ = Boolean(param5[param2]);
  659.                   if(_loc10_ && !_loc11_)
  660.                   {
  661.                      return 1;
  662.                   }
  663.                   if(_loc11_ && !_loc10_)
  664.                   {
  665.                      return -1;
  666.                   }
  667.                   if(_loc11_ && _loc10_)
  668.                   {
  669.                      return 0;
  670.                   }
  671.                   param5[param1] = true;
  672.                   param5[param2] = true;
  673.                   if(param4 != -1 && param3 > param4)
  674.                   {
  675.                      _loc8_ = stringCompare(param1.toString(),param2.toString());
  676.                   }
  677.                   else if(param1 is Array && param2 is Array)
  678.                   {
  679.                      _loc8_ = arrayCompare(param1 as Array,param2 as Array,param3,param4,param5);
  680.                   }
  681.                   else if(param1 is Date && param2 is Date)
  682.                   {
  683.                      _loc8_ = dateCompare(param1 as Date,param2 as Date);
  684.                   }
  685.                   else if(param1 is IList && param2 is IList)
  686.                   {
  687.                      _loc8_ = listCompare(param1 as IList,param2 as IList,param3,param4,param5);
  688.                   }
  689.                   else if(param1 is ByteArray && param2 is ByteArray)
  690.                   {
  691.                      _loc8_ = byteArrayCompare(param1 as ByteArray,param2 as ByteArray);
  692.                   }
  693.                   else
  694.                   {
  695.                      if(getQualifiedClassName(param1) != getQualifiedClassName(param2))
  696.                      {
  697.                         return 1;
  698.                      }
  699.                      _loc12_ = getClassInfo(param1).properties;
  700.                      if(getQualifiedClassName(param1) == "Object")
  701.                      {
  702.                         _loc13_ = getClassInfo(param2).properties;
  703.                         _loc8_ = arrayCompare(_loc12_,_loc13_,param3,_loc9_,param5);
  704.                      }
  705.                      if(_loc8_ != 0)
  706.                      {
  707.                         return _loc8_;
  708.                      }
  709.                      _loc17_ = 0;
  710.                      while(_loc17_ < _loc12_.length)
  711.                      {
  712.                         _loc14_ = _loc12_[_loc17_];
  713.                         _loc15_ = param1[_loc14_];
  714.                         _loc16_ = param2[_loc14_];
  715.                         _loc8_ = internalCompare(_loc15_,_loc16_,param3 + 1,_loc9_,param5);
  716.                         if(_loc8_ != 0)
  717.                         {
  718.                            _loc17_ = int(_loc12_.length);
  719.                         }
  720.                         _loc17_++;
  721.                      }
  722.                   }
  723.                   break;
  724.             }
  725.             return _loc8_;
  726.          }
  727.          return stringCompare(_loc6_,_loc7_);
  728.       }
  729.       
  730.       public static function hasMetadata(param1:Object, param2:String, param3:String, param4:Array = null, param5:Object = null) : Boolean
  731.       {
  732.          var _loc6_:Object = getClassInfo(param1,param4,param5);
  733.          var _loc7_:Object = _loc6_["metadata"];
  734.          return internalHasMetadata(_loc7_,param2,param3);
  735.       }
  736.       
  737.       private static function internalHasMetadata(param1:Object, param2:String, param3:String) : Boolean
  738.       {
  739.          var _loc4_:Object = null;
  740.          if(param1 != null)
  741.          {
  742.             _loc4_ = param1[param2];
  743.             if(_loc4_ != null)
  744.             {
  745.                if(_loc4_[param3] != null)
  746.                {
  747.                   return true;
  748.                }
  749.             }
  750.          }
  751.          return false;
  752.       }
  753.       
  754.       public static function toString(param1:Object, param2:Array = null, param3:Array = null) : String
  755.       {
  756.          if(param3 == null)
  757.          {
  758.             param3 = defaultToStringExcludes;
  759.          }
  760.          refCount = 0;
  761.          return internalToString(param1,0,null,param2,param3);
  762.       }
  763.       
  764.       private static function byteArrayCompare(param1:ByteArray, param2:ByteArray) : int
  765.       {
  766.          var _loc4_:int = 0;
  767.          var _loc3_:int = 0;
  768.          if(param1.length != param2.length)
  769.          {
  770.             if(param1.length < param2.length)
  771.             {
  772.                _loc3_ = -1;
  773.             }
  774.             else
  775.             {
  776.                _loc3_ = 1;
  777.             }
  778.          }
  779.          else
  780.          {
  781.             param1.position = 0;
  782.             param2.position = 0;
  783.             _loc4_ = 0;
  784.             while(_loc4_ < param1.length)
  785.             {
  786.                _loc3_ = numericCompare(param1.readByte(),param2.readByte());
  787.                if(_loc3_ != 0)
  788.                {
  789.                   _loc4_ = int(param1.length);
  790.                }
  791.                _loc4_++;
  792.             }
  793.          }
  794.          return _loc3_;
  795.       }
  796.       
  797.       public static function copy(param1:Object) : Object
  798.       {
  799.          var _loc2_:ByteArray = new ByteArray();
  800.          _loc2_.writeObject(param1);
  801.          _loc2_.position = 0;
  802.          return _loc2_.readObject();
  803.       }
  804.       
  805.       private static function getCacheKey(param1:Object, param2:Array = null, param3:Object = null) : String
  806.       {
  807.          var _loc5_:uint = 0;
  808.          var _loc6_:String = null;
  809.          var _loc7_:String = null;
  810.          var _loc8_:String = null;
  811.          var _loc4_:String = getQualifiedClassName(param1);
  812.          if(param2 != null)
  813.          {
  814.             _loc5_ = 0;
  815.             while(_loc5_ < param2.length)
  816.             {
  817.                _loc6_ = param2[_loc5_] as String;
  818.                if(_loc6_ != null)
  819.                {
  820.                   _loc4_ += _loc6_;
  821.                }
  822.                _loc5_++;
  823.             }
  824.          }
  825.          if(param3 != null)
  826.          {
  827.             for(_loc7_ in param3)
  828.             {
  829.                _loc4_ += _loc7_;
  830.                _loc8_ = param3[_loc7_] as String;
  831.                if(_loc8_ != null)
  832.                {
  833.                   _loc4_ += _loc8_;
  834.                }
  835.             }
  836.          }
  837.          return _loc4_;
  838.       }
  839.    }
  840. }
  841.  
  842.